package gui;

import logic.AlchemikaGenerator;

//public class Controller {
//
//	@SuppressWarnings("unused")
//	private AlchemikaGenerator Generator;
//
//	/**
//	 * Konstruktor
//	 */
//	public Controller(AlchemikaGenerator Generator) {
//		this.Generator = Generator;
//	}
//	
//}

/*
 * @author DIGERATI CRACKERS
 * 
 * Description:
 * 
 * Version Date       Comments 
 * 1.01.01 18.07.2009 created
 *
 */

import java.awt.event.*;

import javax.swing.*;
import javax.swing.event.*;

// handleTreeTreeExpandedEvent
// handleTreeTreeCollapsedEvent
// handleTreeMousePressedEvent
// handleTreeMouseReleasedEvent

public class Controller2 implements ActionListener, ChangeListener, ItemListener, KeyListener, ListSelectionListener, MenuListener, TreeSelectionListener, WindowListener {
  Presentation gui;
  JButton AlleBrauenButton;
  JButton BrauenButton;
  JButton ZauberAddButton;
  JButton ZauberRemoveButton;
  JButton tbClose;
  JButton tbNew;
  JButton tbOpen;
  JButton tbSave;
  JButton toConfigButton;
  JCheckBox KomponentenCheckBox;
  JCheckBox MeisterhandwerkCheckBox;
  JCheckBox SchaleCheckBox;
  JComboBox AlchemikumComboBox;
  JComboBox CharakterComboBox;
  JComboBox SubstituteComboBox;
  JComboBox ZauberComboBox;
  JFrame mainJFrame;
  JList ZauberList;
  JMenu mnEdit;
  JMenu mnFile;
  JMenu mnHelp;
  JMenuItem emCopy;
  JMenuItem emCut;
  JMenuItem emPaste;
  JMenuItem emRedo;
  JMenuItem emSelectAll;
  JMenuItem emUndo;
  JMenuItem fmClose;
  JMenuItem fmDelete;
  JMenuItem fmExit;
  JMenuItem fmNew;
  JMenuItem fmOpen;
  JMenuItem fmPreferences;
  JMenuItem fmSave;
  JMenuItem fmSaveAs;
  JMenuItem hmAbout;
  JSpinner AlchemieTaWSpinner;
  JSpinner AnzahlSpinner;
  JSpinner AsPsSpinner;
  JSpinner CHSpinner;
  JSpinner FFSpinner;
  JSpinner GESpinner;
  JSpinner INSpinner;
  JSpinner KKSpinner;
  JSpinner KLSpinner;
  JSpinner KOSpinner;
  JSpinner MUSpinner;
  JTabbedPane tbBottom;
  JTextField NameTextfield;
  JTree tree;

  private AlchemikaGenerator Generator;

/**
 * Konstruktor
 */
public Controller2(AlchemikaGenerator Generator) {
	this.Generator = Generator;
	this.gui = this.Generator.getGUIPresentation();
    AlchemieTaWSpinner = (JSpinner)gui.getComponent("AlchemieTaWSpinner");
    AlchemieTaWSpinner.addChangeListener(this);
    AlchemikumComboBox = (JComboBox)gui.getComponent("AlchemikumComboBox");
    AlchemikumComboBox.addItemListener(this);
    AlleBrauenButton = (JButton)gui.getComponent("AlleBrauenButton");
    AlleBrauenButton.addActionListener(this);
    AnzahlSpinner = (JSpinner)gui.getComponent("AnzahlSpinner");
    AnzahlSpinner.addChangeListener(this);
    AsPsSpinner = (JSpinner)gui.getComponent("AsPsSpinner");
    AsPsSpinner.addChangeListener(this);
    BrauenButton = (JButton)gui.getComponent("BrauenButton");
    BrauenButton.addActionListener(this);
    CHSpinner = (JSpinner)gui.getComponent("CHSpinner");
    CHSpinner.addChangeListener(this);
    CharakterComboBox = (JComboBox)gui.getComponent("CharakterComboBox");
    CharakterComboBox.addItemListener(this);
    FFSpinner = (JSpinner)gui.getComponent("FFSpinner");
    FFSpinner.addChangeListener(this);
    GESpinner = (JSpinner)gui.getComponent("GESpinner");
    GESpinner.addChangeListener(this);
    INSpinner = (JSpinner)gui.getComponent("INSpinner");
    INSpinner.addChangeListener(this);
    KKSpinner = (JSpinner)gui.getComponent("KKSpinner");
    KKSpinner.addChangeListener(this);
    KLSpinner = (JSpinner)gui.getComponent("KLSpinner");
    KLSpinner.addChangeListener(this);
    KOSpinner = (JSpinner)gui.getComponent("KOSpinner");
    KOSpinner.addChangeListener(this);
    KomponentenCheckBox = (JCheckBox)gui.getComponent("KomponentenCheckBox");
    KomponentenCheckBox.addItemListener(this);
    MUSpinner = (JSpinner)gui.getComponent("MUSpinner");
    MUSpinner.addChangeListener(this);
    MeisterhandwerkCheckBox = (JCheckBox)gui.getComponent("MeisterhandwerkCheckBox");
    MeisterhandwerkCheckBox.addItemListener(this);
    NameTextfield = (JTextField)gui.getComponent("NameTextfield");
    NameTextfield.addKeyListener(this);
    SchaleCheckBox = (JCheckBox)gui.getComponent("SchaleCheckBox");
    SchaleCheckBox.addItemListener(this);
    SubstituteComboBox = (JComboBox)gui.getComponent("SubstituteComboBox");
    SubstituteComboBox.addItemListener(this);
    ZauberAddButton = (JButton)gui.getComponent("ZauberAddButton");
    ZauberAddButton.addActionListener(this);
    ZauberComboBox = (JComboBox)gui.getComponent("ZauberComboBox");
    ZauberComboBox.addItemListener(this);
    ZauberList = (JList)gui.getComponent("ZauberList");
    ZauberList.addListSelectionListener(this);
    ZauberRemoveButton = (JButton)gui.getComponent("ZauberRemoveButton");
    ZauberRemoveButton.addActionListener(this);
    emCopy = (JMenuItem)gui.getComponent("emCopy");
    emCopy.addActionListener(this);
    emCut = (JMenuItem)gui.getComponent("emCut");
    emCut.addActionListener(this);
    emPaste = (JMenuItem)gui.getComponent("emPaste");
    emPaste.addActionListener(this);
    emRedo = (JMenuItem)gui.getComponent("emRedo");
    emRedo.addActionListener(this);
    emSelectAll = (JMenuItem)gui.getComponent("emSelectAll");
    emSelectAll.addActionListener(this);
    emUndo = (JMenuItem)gui.getComponent("emUndo");
    emUndo.addActionListener(this);
    fmClose = (JMenuItem)gui.getComponent("fmClose");
    fmClose.addActionListener(this);
    fmDelete = (JMenuItem)gui.getComponent("fmDelete");
    fmDelete.addActionListener(this);
    fmExit = (JMenuItem)gui.getComponent("fmExit");
    fmExit.addActionListener(this);
    fmNew = (JMenuItem)gui.getComponent("fmNew");
    fmNew.addActionListener(this);
    fmOpen = (JMenuItem)gui.getComponent("fmOpen");
    fmOpen.addActionListener(this);
    fmPreferences = (JMenuItem)gui.getComponent("fmPreferences");
    fmPreferences.addActionListener(this);
    fmSave = (JMenuItem)gui.getComponent("fmSave");
    fmSave.addActionListener(this);
    fmSaveAs = (JMenuItem)gui.getComponent("fmSaveAs");
    fmSaveAs.addActionListener(this);
    hmAbout = (JMenuItem)gui.getComponent("hmAbout");
    hmAbout.addActionListener(this);
    mainJFrame = (JFrame)gui.getComponent("mainJFrame");
    mainJFrame.addWindowListener(this);
    mnEdit = (JMenu)gui.getComponent("mnEdit");
    mnEdit.addMenuListener(this);
    mnFile = (JMenu)gui.getComponent("mnFile");
    mnFile.addMenuListener(this);
    mnHelp = (JMenu)gui.getComponent("mnHelp");
    mnHelp.addMenuListener(this);
    tbBottom = (JTabbedPane)gui.getComponent("tbBottom");
    tbBottom.addChangeListener(this);
    tbClose = (JButton)gui.getComponent("tbClose");
    tbClose.addActionListener(this);
    tbNew = (JButton)gui.getComponent("tbNew");
    tbNew.addActionListener(this);
    tbOpen = (JButton)gui.getComponent("tbOpen");
    tbOpen.addActionListener(this);
    tbSave = (JButton)gui.getComponent("tbSave");
    tbSave.addActionListener(this);
    toConfigButton = (JButton)gui.getComponent("toConfigButton");
    toConfigButton.addActionListener(this);
    tree = (JTree)gui.getComponent("tree");
//    tree.addTreeSelectionListener(this);
    initialize();
  }

//==============================================================================
// Implementing the ActionListener Interface ...
//------------------------------------------------------------------------------

  public void actionPerformed(ActionEvent e)
  { try
    { Object component = e.getSource();
      if (component.equals(AlleBrauenButton)) handleAlleBrauenButtonActionPerformedEvent(e);
      else if (component.equals(BrauenButton)) handleBrauenButtonActionPerformedEvent(e);
      else if (component.equals(ZauberAddButton)) handleZauberAddButtonActionPerformedEvent(e);
      else if (component.equals(ZauberRemoveButton)) handleZauberRemoveButtonActionPerformedEvent(e);
      else if (component.equals(emCopy)) handleEmCopyActionPerformedEvent(e);
      else if (component.equals(emCut)) handleEmCutActionPerformedEvent(e);
      else if (component.equals(emPaste)) handleEmPasteActionPerformedEvent(e);
      else if (component.equals(emRedo)) handleEmRedoActionPerformedEvent(e);
      else if (component.equals(emSelectAll)) handleEmSelectAllActionPerformedEvent(e);
      else if (component.equals(emUndo)) handleEmUndoActionPerformedEvent(e);
      else if (component.equals(fmClose)) handleFmCloseActionPerformedEvent(e);
      else if (component.equals(fmDelete)) handleFmDeleteActionPerformedEvent(e);
      else if (component.equals(fmExit)) handleFmExitActionPerformedEvent(e);
      else if (component.equals(fmNew)) handleFmNewActionPerformedEvent(e);
      else if (component.equals(fmOpen)) handleFmOpenActionPerformedEvent(e);
      else if (component.equals(fmPreferences)) handleFmPreferencesActionPerformedEvent(e);
      else if (component.equals(fmSave)) handleFmSaveActionPerformedEvent(e);
      else if (component.equals(fmSaveAs)) handleFmSaveAsActionPerformedEvent(e);
      else if (component.equals(hmAbout)) handleHmAboutActionPerformedEvent(e);
      else if (component.equals(tbClose)) handleTbCloseActionPerformedEvent(e);
      else if (component.equals(tbNew)) handleTbNewActionPerformedEvent(e);
      else if (component.equals(tbOpen)) handleTbOpenActionPerformedEvent(e);
      else if (component.equals(tbSave)) handleTbSaveActionPerformedEvent(e);
      else if (component.equals(toConfigButton)) handleToConfigButtonActionPerformedEvent(e);
    }
    catch (Exception ex)
    { // in order to avoid throwing exceptions into the event-dispatching thread
      handleGuiControllerException(ex);
    }
  }

//==============================================================================
// Implementing the ChangeListener Interface ...
//------------------------------------------------------------------------------

  public void stateChanged(ChangeEvent e)
  { try
    { Object component = e.getSource();
      if (component.equals(AlchemieTaWSpinner)) handleAlchemieTaWSpinnerStateChangedEvent(e);
      else if (component.equals(AnzahlSpinner)) handleAnzahlSpinnerStateChangedEvent(e);
      else if (component.equals(AsPsSpinner)) handleAsPsSpinnerStateChangedEvent(e);
      else if (component.equals(CHSpinner)) handleCHSpinnerStateChangedEvent(e);
      else if (component.equals(FFSpinner)) handleFFSpinnerStateChangedEvent(e);
      else if (component.equals(GESpinner)) handleGESpinnerStateChangedEvent(e);
      else if (component.equals(INSpinner)) handleINSpinnerStateChangedEvent(e);
      else if (component.equals(KKSpinner)) handleKKSpinnerStateChangedEvent(e);
      else if (component.equals(KLSpinner)) handleKLSpinnerStateChangedEvent(e);
      else if (component.equals(KOSpinner)) handleKOSpinnerStateChangedEvent(e);
      else if (component.equals(MUSpinner)) handleMUSpinnerStateChangedEvent(e);
      else if (component.equals(tbBottom)) handleTbBottomStateChangedEvent(e);
    }
    catch (Exception ex)
    { // in order to avoid throwing exceptions into the event-dispatching thread
      handleGuiControllerException(ex);
    }
  }

//==============================================================================
// Implementing the ItemListener Interface ...
//------------------------------------------------------------------------------

  public void itemStateChanged(ItemEvent e)
  { try
    { Object component = e.getSource();
      if (component.equals(AlchemikumComboBox)) handleAlchemikumComboBoxItemStateChangedEvent(e);
      else if (component.equals(CharakterComboBox)) handleCharakterComboBoxItemStateChangedEvent(e);
      else if (component.equals(KomponentenCheckBox)) handleKomponentenCheckBoxItemStateChangedEvent(e);
      else if (component.equals(MeisterhandwerkCheckBox)) handleMeisterhandwerkCheckBoxItemStateChangedEvent(e);
      else if (component.equals(SchaleCheckBox)) handleSchaleCheckBoxItemStateChangedEvent(e);
      else if (component.equals(SubstituteComboBox)) handleSubstituteComboBoxItemStateChangedEvent(e);
      else if (component.equals(ZauberComboBox)) handleZauberComboBoxItemStateChangedEvent(e);
    }
    catch (Exception ex)
    { // in order to avoid throwing exceptions into the event-dispatching thread
      handleGuiControllerException(ex);
    }
  }

//==============================================================================
// Implementing the KeyListener Interface ...
//------------------------------------------------------------------------------

  public void keyTyped(KeyEvent e)
  { try
    { Object component = e.getSource();
      if (component.equals(NameTextfield)) handleNameTextfieldKeyTypedEvent(e);
    }
    catch (Exception ex)
    { // in order to avoid throwing exceptions into the event-dispatching thread
      handleGuiControllerException(ex);
    }
  }

//------------------------------------------------------------------------------

  public void keyPressed(KeyEvent e)
  { try
    { Object component = e.getSource();
      if (component.equals(NameTextfield)) handleNameTextfieldKeyPressedEvent(e);
    }
    catch (Exception ex)
    { // in order to avoid throwing exceptions into the event-dispatching thread
      handleGuiControllerException(ex);
    }
  }

//------------------------------------------------------------------------------

  public void keyReleased(KeyEvent e)
  { try
    { Object component = e.getSource();
      if (component.equals(NameTextfield)) handleNameTextfieldKeyReleasedEvent(e);
    }
    catch (Exception ex)
    { // in order to avoid throwing exceptions into the event-dispatching thread
      handleGuiControllerException(ex);
    }
  }

//==============================================================================
// Implementing the ListSelectionListener Interface ...
//------------------------------------------------------------------------------

  public void valueChanged(ListSelectionEvent e)
  { try
    { Object component = e.getSource();
      if (component.equals(ZauberList)) handleZauberListValueChangedEvent(e);
    }
    catch (Exception ex)
    { // in order to avoid throwing exceptions into the event-dispatching thread
      handleGuiControllerException(ex);
    }
  }

//==============================================================================
// Implementing the MenuListener Interface ...
//------------------------------------------------------------------------------

  public void menuSelected(MenuEvent e)
  { try
    { Object component = e.getSource();
      if (component.equals(mnEdit)) handleMnEditMenuSelectedEvent(e);
      else if (component.equals(mnFile)) handleMnFileMenuSelectedEvent(e);
      else if (component.equals(mnHelp)) handleMnHelpMenuSelectedEvent(e);
    }
    catch (Exception ex)
    { // in order to avoid throwing exceptions into the event-dispatching thread
      handleGuiControllerException(ex);
    }
  }

//------------------------------------------------------------------------------

  public void menuDeselected(MenuEvent e)
  { try
    { Object component = e.getSource();
      if (component.equals(mnEdit)) handleMnEditMenuDeselectedEvent(e);
      else if (component.equals(mnFile)) handleMnFileMenuDeselectedEvent(e);
      else if (component.equals(mnHelp)) handleMnHelpMenuDeselectedEvent(e);
    }
    catch (Exception ex)
    { // in order to avoid throwing exceptions into the event-dispatching thread
      handleGuiControllerException(ex);
    }
  }

//------------------------------------------------------------------------------

  public void menuCanceled(MenuEvent e)
  { try
    { Object component = e.getSource();
      if (component.equals(mnEdit)) handleMnEditMenuCanceledEvent(e);
      else if (component.equals(mnFile)) handleMnFileMenuCanceledEvent(e);
      else if (component.equals(mnHelp)) handleMnHelpMenuCanceledEvent(e);
    }
    catch (Exception ex)
    { // in order to avoid throwing exceptions into the event-dispatching thread
      handleGuiControllerException(ex);
    }
  }

//==============================================================================
// Implementing the TreeSelectionListener Interface ...
//------------------------------------------------------------------------------

  public void valueChanged(TreeSelectionEvent e)
  { try
    { Object component = e.getSource();
      if (component.equals(tree)) handleTreeValueChangedEvent(e);
    }
    catch (Exception ex)
    { // in order to avoid throwing exceptions into the event-dispatching thread
      handleGuiControllerException(ex);
    }
  }

//==============================================================================
// Implementing the WindowListener Interface ...
//------------------------------------------------------------------------------

  public void windowOpened(WindowEvent e)
  { try
    { Object component = e.getSource();
      if (component.equals(mainJFrame)) handleMainJFrameWindowOpenedEvent(e);
    }
    catch (Exception ex)
    { // in order to avoid throwing exceptions into the event-dispatching thread
      handleGuiControllerException(ex);
    }
  }

//------------------------------------------------------------------------------

  public void windowActivated(WindowEvent e)
  { try
    { Object component = e.getSource();
      if (component.equals(mainJFrame)) handleMainJFrameWindowActivatedEvent(e);
    }
    catch (Exception ex)
    { // in order to avoid throwing exceptions into the event-dispatching thread
      handleGuiControllerException(ex);
    }
  }

//------------------------------------------------------------------------------

  public void windowDeactivated(WindowEvent e)
  { try
    { Object component = e.getSource();
      if (component.equals(mainJFrame)) handleMainJFrameWindowDeactivatedEvent(e);
    }
    catch (Exception ex)
    { // in order to avoid throwing exceptions into the event-dispatching thread
      handleGuiControllerException(ex);
    }
  }

//------------------------------------------------------------------------------

  public void windowClosing(WindowEvent e)
  { try
    { Object component = e.getSource();
      if (component.equals(mainJFrame)) handleMainJFrameWindowClosingEvent(e);
    }
    catch (Exception ex)
    { // in order to avoid throwing exceptions into the event-dispatching thread
      handleGuiControllerException(ex);
    }
  }

//------------------------------------------------------------------------------

  public void windowClosed(WindowEvent e)
  { try
    { Object component = e.getSource();
      if (component.equals(mainJFrame)) handleMainJFrameWindowClosedEvent(e);
    }
    catch (Exception ex)
    { // in order to avoid throwing exceptions into the event-dispatching thread
      handleGuiControllerException(ex);
    }
  }

//------------------------------------------------------------------------------

  public void windowIconified(WindowEvent e)
  { try
    { Object component = e.getSource();
      if (component.equals(mainJFrame)) handleMainJFrameWindowIconifiedEvent(e);
    }
    catch (Exception ex)
    { // in order to avoid throwing exceptions into the event-dispatching thread
      handleGuiControllerException(ex);
    }
  }

//------------------------------------------------------------------------------

  public void windowDeiconified(WindowEvent e)
  { try
    { Object component = e.getSource();
      if (component.equals(mainJFrame)) handleMainJFrameWindowDeiconifiedEvent(e);
    }
    catch (Exception ex)
    { // in order to avoid throwing exceptions into the event-dispatching thread
      handleGuiControllerException(ex);
    }
  }

//==============================================================================
// Customize event-handling within the following methods ...
//------------------------------------------------------------------------------

  void initialize()
  { System.out.println("initialize()");
  }

  void handleGuiControllerException(Exception ex)
  { // in order to avoid throwing exceptions into the event-dispatching thread
    ex.printStackTrace(System.err);
  }
 
 public void treeCollapsed(TreeExpansionEvent e)
 { try
   { Object component = e.getSource();
     if (component.equals(tree)) handleTreeTreeCollapsedEvent(e);
   }
   catch (Exception ex)
   { // in order to avoid throwing exceptions into the event-dispatching thread
     handleGuiControllerException(ex);
   }
 }

  public void treeExpanded(TreeExpansionEvent e)
  { try
    { Object component = e.getSource();
      if (component.equals(tree)) handleTreeTreeExpandedEvent(e);
    }
    catch (Exception ex)
    { // in order to avoid throwing exceptions into the event-dispatching thread
      handleGuiControllerException(ex);
    }
  }
  
  void handleTreeMousePressedEvent(MouseEvent e) throws Exception
  { System.out.println("handleTreeMousePressedEvent");
  }

  void handleTreeMouseReleasedEvent(MouseEvent e) throws Exception
  { System.out.println("handleTreeMouseReleasedEvent");
  }


  public void mouseReleased(MouseEvent e)
  { try
    { Object component = e.getSource();
    if (component.equals(tree)) handleTreeMouseReleasedEvent(e);
//      else if (component.equals(tree)) handleTreeMouseReleasedEvent(e);
    }
    catch (Exception ex)
    { // in order to avoid throwing exceptions into the event-dispatching thread
      handleGuiControllerException(ex);
    }
  }


  public void mousePressed(MouseEvent e)
  { try
    { Object component = e.getSource();
      if (component.equals(tree)) handleTreeMousePressedEvent(e);
    }
    catch (Exception ex)
    { // in order to avoid throwing exceptions into the event-dispatching thread
      handleGuiControllerException(ex);
    }
  }

 void handleTreeTreeCollapsedEvent(TreeExpansionEvent e) throws Exception
 { System.out.println("handleTreeTreeCollapsedEvent");
 }

//------------------------------------------------------------------------------

 void handleTreeTreeExpandedEvent(TreeExpansionEvent e) throws Exception
 { System.out.println("handleTreeTreeExpandedEvent");
 }

//==============================================================================
// ActionListener event handling ...
//------------------------------------------------------------------------------

  void handleAlleBrauenButtonActionPerformedEvent(ActionEvent e) throws Exception
  { System.out.println("handleAlleBrauenButtonActionPerformedEvent");
  }

  void handleBrauenButtonActionPerformedEvent(ActionEvent e) throws Exception
  { System.out.println("handleBrauenButtonActionPerformedEvent");
  }

  void handleZauberAddButtonActionPerformedEvent(ActionEvent e) throws Exception
  { System.out.println("handleZauberAddButtonActionPerformedEvent");
  }

  void handleZauberRemoveButtonActionPerformedEvent(ActionEvent e) throws Exception
  { System.out.println("handleZauberRemoveButtonActionPerformedEvent");
  }

  void handleEmCopyActionPerformedEvent(ActionEvent e) throws Exception
  { System.out.println("handleEmCopyActionPerformedEvent");
  }

  void handleEmCutActionPerformedEvent(ActionEvent e) throws Exception
  { System.out.println("handleEmCutActionPerformedEvent");
  }

  void handleEmPasteActionPerformedEvent(ActionEvent e) throws Exception
  { System.out.println("handleEmPasteActionPerformedEvent");
  }

  void handleEmRedoActionPerformedEvent(ActionEvent e) throws Exception
  { System.out.println("handleEmRedoActionPerformedEvent");
  }

  void handleEmSelectAllActionPerformedEvent(ActionEvent e) throws Exception
  { System.out.println("handleEmSelectAllActionPerformedEvent");
  }

  void handleEmUndoActionPerformedEvent(ActionEvent e) throws Exception
  { System.out.println("handleEmUndoActionPerformedEvent");
  }

  void handleFmCloseActionPerformedEvent(ActionEvent e) throws Exception
  { System.out.println("handleFmCloseActionPerformedEvent");
  }

  void handleFmDeleteActionPerformedEvent(ActionEvent e) throws Exception
  { System.out.println("handleFmDeleteActionPerformedEvent");
  }

  void handleFmExitActionPerformedEvent(ActionEvent e) throws Exception
  { System.out.println("handleFmExitActionPerformedEvent");
  }

  void handleFmNewActionPerformedEvent(ActionEvent e) throws Exception
  { System.out.println("handleFmNewActionPerformedEvent");
  }

  void handleFmOpenActionPerformedEvent(ActionEvent e) throws Exception
  { System.out.println("handleFmOpenActionPerformedEvent");
  }

  void handleFmPreferencesActionPerformedEvent(ActionEvent e) throws Exception
  { System.out.println("handleFmPreferencesActionPerformedEvent");
  }

  void handleFmSaveActionPerformedEvent(ActionEvent e) throws Exception
  { System.out.println("handleFmSaveActionPerformedEvent");
  }

  void handleFmSaveAsActionPerformedEvent(ActionEvent e) throws Exception
  { System.out.println("handleFmSaveAsActionPerformedEvent");
  }

  void handleHmAboutActionPerformedEvent(ActionEvent e) throws Exception
  { System.out.println("handleHmAboutActionPerformedEvent");
  }

  void handleTbCloseActionPerformedEvent(ActionEvent e) throws Exception
  { System.out.println("handleTbCloseActionPerformedEvent");
  }

  void handleTbNewActionPerformedEvent(ActionEvent e) throws Exception
  { System.out.println("handleTbNewActionPerformedEvent");
  }

  void handleTbOpenActionPerformedEvent(ActionEvent e) throws Exception
  { System.out.println("handleTbOpenActionPerformedEvent");
  }

  void handleTbSaveActionPerformedEvent(ActionEvent e) throws Exception
  { System.out.println("handleTbSaveActionPerformedEvent");
  }

  void handleToConfigButtonActionPerformedEvent(ActionEvent e) throws Exception
  { System.out.println("handleToConfigButtonActionPerformedEvent");
  }

//==============================================================================
// ChangeListener event handling ...
//------------------------------------------------------------------------------

  void handleAlchemieTaWSpinnerStateChangedEvent(ChangeEvent e) throws Exception
  { System.out.println("handleAlchemieTaWSpinnerStateChangedEvent");
  }

  void handleAnzahlSpinnerStateChangedEvent(ChangeEvent e) throws Exception
  { System.out.println("handleAnzahlSpinnerStateChangedEvent");
  }

  void handleAsPsSpinnerStateChangedEvent(ChangeEvent e) throws Exception
  { System.out.println("handleAsPsSpinnerStateChangedEvent");
  }

  void handleCHSpinnerStateChangedEvent(ChangeEvent e) throws Exception
  { System.out.println("handleCHSpinnerStateChangedEvent");
  }

  void handleFFSpinnerStateChangedEvent(ChangeEvent e) throws Exception
  { System.out.println("handleFFSpinnerStateChangedEvent");
  }

  void handleGESpinnerStateChangedEvent(ChangeEvent e) throws Exception
  { System.out.println("handleGESpinnerStateChangedEvent");
  }

  void handleINSpinnerStateChangedEvent(ChangeEvent e) throws Exception
  { System.out.println("handleINSpinnerStateChangedEvent");
  }

  void handleKKSpinnerStateChangedEvent(ChangeEvent e) throws Exception
  { System.out.println("handleKKSpinnerStateChangedEvent");
  }

  void handleKLSpinnerStateChangedEvent(ChangeEvent e) throws Exception
  { System.out.println("handleKLSpinnerStateChangedEvent");
  }

  void handleKOSpinnerStateChangedEvent(ChangeEvent e) throws Exception
  { System.out.println("handleKOSpinnerStateChangedEvent");
  }

  void handleMUSpinnerStateChangedEvent(ChangeEvent e) throws Exception
  { System.out.println("handleMUSpinnerStateChangedEvent");
  }

  void handleTbBottomStateChangedEvent(ChangeEvent e) throws Exception
  { System.out.println("handleTbBottomStateChangedEvent");
  }

//==============================================================================
// ItemListener event handling ...
//------------------------------------------------------------------------------

  void handleAlchemikumComboBoxItemStateChangedEvent(ItemEvent e) throws Exception
  { System.out.println("handleAlchemikumComboBoxItemStateChangedEvent");
  }

  void handleCharakterComboBoxItemStateChangedEvent(ItemEvent e) throws Exception
  { System.out.println("handleCharakterComboBoxItemStateChangedEvent");
  }

  void handleKomponentenCheckBoxItemStateChangedEvent(ItemEvent e) throws Exception
  { System.out.println("handleKomponentenCheckBoxItemStateChangedEvent");
  }

  void handleMeisterhandwerkCheckBoxItemStateChangedEvent(ItemEvent e) throws Exception
  { System.out.println("handleMeisterhandwerkCheckBoxItemStateChangedEvent");
  }

  void handleSchaleCheckBoxItemStateChangedEvent(ItemEvent e) throws Exception
  { System.out.println("handleSchaleCheckBoxItemStateChangedEvent");
  }

  void handleSubstituteComboBoxItemStateChangedEvent(ItemEvent e) throws Exception
  { System.out.println("handleSubstituteComboBoxItemStateChangedEvent");
  }

  void handleZauberComboBoxItemStateChangedEvent(ItemEvent e) throws Exception
  { System.out.println("handleZauberComboBoxItemStateChangedEvent");
  }

//==============================================================================
// KeyListener event handling ...
//------------------------------------------------------------------------------

  void handleNameTextfieldKeyTypedEvent(KeyEvent e) throws Exception
  { System.out.println("handleNameTextfieldKeyTypedEvent");
  }

//------------------------------------------------------------------------------

  void handleNameTextfieldKeyPressedEvent(KeyEvent e) throws Exception
  { System.out.println("handleNameTextfieldKeyPressedEvent");
  }

//------------------------------------------------------------------------------

  void handleNameTextfieldKeyReleasedEvent(KeyEvent e) throws Exception
  { System.out.println("handleNameTextfieldKeyReleasedEvent");
  }

//==============================================================================
// ListSelectionListener event handling ...
//------------------------------------------------------------------------------

  void handleZauberListValueChangedEvent(ListSelectionEvent e) throws Exception
  { System.out.println("handleZauberListValueChangedEvent");
  }

//==============================================================================
// MenuListener event handling ...
//------------------------------------------------------------------------------

  void handleMnEditMenuSelectedEvent(MenuEvent e) throws Exception
  { System.out.println("handleMnEditMenuSelectedEvent");
  }

  void handleMnFileMenuSelectedEvent(MenuEvent e) throws Exception
  { System.out.println("handleMnFileMenuSelectedEvent");
  }

  void handleMnHelpMenuSelectedEvent(MenuEvent e) throws Exception
  { System.out.println("handleMnHelpMenuSelectedEvent");
  }

//------------------------------------------------------------------------------

  void handleMnEditMenuDeselectedEvent(MenuEvent e) throws Exception
  { System.out.println("handleMnEditMenuDeselectedEvent");
  }

  void handleMnFileMenuDeselectedEvent(MenuEvent e) throws Exception
  { System.out.println("handleMnFileMenuDeselectedEvent");
  }

  void handleMnHelpMenuDeselectedEvent(MenuEvent e) throws Exception
  { System.out.println("handleMnHelpMenuDeselectedEvent");
  }

//------------------------------------------------------------------------------

  void handleMnEditMenuCanceledEvent(MenuEvent e) throws Exception
  { System.out.println("handleMnEditMenuCanceledEvent");
  }

  void handleMnFileMenuCanceledEvent(MenuEvent e) throws Exception
  { System.out.println("handleMnFileMenuCanceledEvent");
  }

  void handleMnHelpMenuCanceledEvent(MenuEvent e) throws Exception
  { System.out.println("handleMnHelpMenuCanceledEvent");
  }

//==============================================================================
// TreeSelectionListener event handling ...
//------------------------------------------------------------------------------

  void handleTreeValueChangedEvent(TreeSelectionEvent e) throws Exception
  { System.out.println("handleTreeValueChangedEvent");
  }

//==============================================================================
// WindowListener event handling ...
//------------------------------------------------------------------------------

  void handleMainJFrameWindowOpenedEvent(WindowEvent e) throws Exception
  { System.out.println("handleMainJFrameWindowOpenedEvent");
  }

//------------------------------------------------------------------------------

  void handleMainJFrameWindowActivatedEvent(WindowEvent e) throws Exception
  { System.out.println("handleMainJFrameWindowActivatedEvent");
  }

//------------------------------------------------------------------------------

  void handleMainJFrameWindowDeactivatedEvent(WindowEvent e) throws Exception
  { System.out.println("handleMainJFrameWindowDeactivatedEvent");
  }

//------------------------------------------------------------------------------

  void handleMainJFrameWindowClosingEvent(WindowEvent e) throws Exception
  { System.out.println("handleMainJFrameWindowClosingEvent");
  }

//------------------------------------------------------------------------------

  void handleMainJFrameWindowClosedEvent(WindowEvent e) throws Exception
  { System.out.println("handleMainJFrameWindowClosedEvent");
  }

//------------------------------------------------------------------------------

  void handleMainJFrameWindowIconifiedEvent(WindowEvent e) throws Exception
  { System.out.println("handleMainJFrameWindowIconifiedEvent");
  }

//------------------------------------------------------------------------------

  void handleMainJFrameWindowDeiconifiedEvent(WindowEvent e) throws Exception
  { System.out.println("handleMainJFrameWindowDeiconifiedEvent");
  }

//==== EOF =====================================================================

}
